package qc.module.platform.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.module.platform.entity.QcDeptUser;
import qc.module.platform.repository.QcDeptUserRepository;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class DeptUserService {
    private QcDeptUserRepository repository;

    @Autowired
    public void setQcDeptUserRepository(QcDeptUserRepository repository) {
        this.repository = repository;
    }

    /***
     * 判断关联关系是否存在
     *
     * @param userId 用户ID
     * @param deptId 部门ID
     * @return boolean
     * @author QuCheng Tech
     * @since 2023/9/2
     */
    public boolean hasExist(int userId, int deptId) {
        LambdaQueryWrapper<QcDeptUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(QcDeptUser::getUserid, userId);
        wrapper.eq(QcDeptUser::getDeptid, deptId);

        QcDeptUser en = repository.selectOne(wrapper);
        if (en != null)
            return true;

        return false;
    }

    /**
     * 新增用户部门联系
     *
     * @param userId 用户ID
     * @param deptId 部门ID
     * @return
     */
    public void add(int userId, int deptId) {
        if (!hasExist(userId, deptId)) {
            QcDeptUser en = new QcDeptUser();
            en.setUserid(userId);
            en.setDeptid(deptId);
            repository.insert(en);
        }
    }

    /**
     * 获取指定用户关联的部门ID集合，需要指定筛选过滤的部门ID结合（外部根据项目得到项目中的部门ID集合）
     *
     * @param userId        用户ID
     * @param filterDeptIds 筛选过滤的部门ID集合，如果为空返回结果为null
     * @return 部门ID集合
     * @author
     */
    public List<Integer> getByUserId(int userId, List<Integer> filterDeptIds) {
        LambdaQueryWrapper<QcDeptUser> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(QcDeptUser::getDeptid);
        wrapper.eq(QcDeptUser::getUserid, userId);
        wrapper.in(QcDeptUser::getDeptid, filterDeptIds);
        //查询数据
        List<QcDeptUser> ens = repository.selectList(wrapper);
        if (ens != null && ens.size() > 0x0) {
            return ens.stream().map(QcDeptUser::getDeptid).collect(Collectors.toList());
        }

        return null;
    }

    /**
     * 删除指定用户ID与部门关联关系，谨慎调用，会删除指定用户ID的所有项目中的部门关联关系（在平台中删除用户时使用）
     *
     * @param userId 用户Id
     * @author 成功返回null
     */
    public void deleteByUserId(int userId) {
        LambdaUpdateWrapper<QcDeptUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(QcDeptUser::getUserid, userId);
        repository.delete(wrapper);
    }

    /**
     * 删除指定用户ID与指定部门ID集合的关联关系，需要外部传入部门ID集合；用于项目中设置用户部门时删除当前项目已有部门与用户关联关系
     *
     * @param userId 用户Id
     * @author 成功返回null
     */
    public void deleteByUserIdAndDeptIds(int userId, List<Integer> filterDeptIds) {
        LambdaUpdateWrapper<QcDeptUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(QcDeptUser::getUserid, userId);
        wrapper.in(QcDeptUser::getDeptid, filterDeptIds);
        repository.delete(wrapper);
    }

    /**
     * 删除指定部门关联的所有用户关系
     *
     * @param deptId 部门id
     * @return 成功返回null
     * @author QcCheng Tech
     * @since 2023/6/29
     */
    public void deleteByDeptId(int deptId) {
        LambdaUpdateWrapper<QcDeptUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(QcDeptUser::getDeptid, deptId);
        repository.delete(wrapper);
    }

    /**
     * 删除指定部门集合关联的所有用户关系
     *
     * @param deptIds 部门id集合
     * @return 成功返回null
     * @author QcCheng Tech
     * @since 2023/6/29
     */
    public void deleteByDeptIds(List<Integer> deptIds) {
        LambdaUpdateWrapper<QcDeptUser> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(QcDeptUser::getDeptid, deptIds);
        repository.delete(wrapper);
    }


    /**
     * 通过项目部门ID集合查询用户和部门的关联关系
     *
     * @return List<QcDeptUser>
     * @author QcCheng Tech
     * @date 2023/9/8
     */
    public List<QcDeptUser> queryByDeptIds(List<Integer> projectDeptsIds) {
        LambdaQueryWrapper<QcDeptUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.select(QcDeptUser::getUserid, QcDeptUser::getDeptid);
        queryWrapper.in(QcDeptUser::getDeptid, projectDeptsIds);
        // 执行查询
        return repository.selectList(queryWrapper);
    }

    /**
     * 获取指定用户关联部门的ID集合
     *
     * @param userId 用户id
     * @return 部门id集合
     * @author
     */
    public List<Integer> getDeptIdsByUserId(int userId) {
        LambdaQueryWrapper<QcDeptUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.select(QcDeptUser::getDeptid);
        queryWrapper.eq(QcDeptUser::getUserid, userId);
        // 执行查询
        List<QcDeptUser> deptUsers = repository.selectList(queryWrapper);

        if (deptUsers != null && !deptUsers.isEmpty()) {
            return deptUsers.stream()
                    .map(QcDeptUser::getDeptid)
                    .collect(Collectors.toList());
        }

        return null;
    }


    /**
     * 获取指定部门关联用户，用户ID集合
     *
     * @param DeptId 部门ID
     * @return 用户id集合
     * @author
     */
    public List<Integer> getUserIdsByDeptId(int DeptId) {
        LambdaQueryWrapper<QcDeptUser> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.select(QcDeptUser::getUserid);
        queryWrapper.eq(QcDeptUser::getDeptid, DeptId);
        // 执行查询
        List<QcDeptUser> deptUsers = repository.selectList(queryWrapper);

        if (deptUsers != null && !deptUsers.isEmpty()) {
            return deptUsers.stream()
                    .map(QcDeptUser::getUserid)
                    .collect(Collectors.toList());
        }
        return null;
    }
}
